const api = require('../../utils/api.js');
const config = require('../../utils/config.js');

Page({
  /**
   * 页面的初始数据
   */
  data: {
    // 从上一页传来的参数
    exampleId: null,
    originalPrompt: '', // 原始提示词（用于显示）
    inputPrompt: '', // 输入框中的提示词
    hasContent: false, // 输入框是否有内容
    
    // 参考图相关
    referenceImage: null, // 参考图信息 {path: '', url: ''}
    showReferenceImage: false, // 是否显示参考图
    
    // 生成参数
    selectedSize: '1:1',
    selectedSizeLabel: '1:1',
    selectedModel: 'standard',
    sizeOptions: [
      { label: '1:1 正方形', value: '1:1', ratio: '1:1', width: 1024, height: 1024 },
      { label: '16:9 横向', value: '16:9', ratio: '16:9', width: 1024, height: 576 },
      { label: '9:16 竖向', value: '9:16', ratio: '9:16', width: 576, height: 1024 },
      { label: '4:3 横向', value: '4:3', ratio: '4:3', width: 1024, height: 768 },
      { label: '3:4 竖向', value: '3:4', ratio: '3:4', width: 768, height: 1024 }
    ],
    modelOptions: [
      { label: '标准模式', value: 'standard' },
      { label: '高质量', value: 'hd' },
      { label: '超高清', value: '4k' }
    ],
    
    // 生成状态
    generating: false,
    progress: 0,
    currentTaskId: null,
    
    // 生成结果
    generatedImages: [], // 三张图片的数组
    
    // 历史记录
    historyList: [],
    
    // UI状态
    showSizeSelector: false,
    showModelSelector: false,
    
    // 图标URLs
    sendIconUrl: '',
    promptExpanded: false, // 提示词是否展开
    showHistory: false, // 是否显示历史记录
    scrollIntoView: '', // scroll-view锚点，用于自动滚动到生成卡片
    scrollTop: 0, // scroll-view滚动位置
    scrollWithAnimation: true, // 控制是否带动画滚动（用于首次进入无动画定位）
    
    // 删除功能相关
    showDeleteButton: false, // 是否显示删除按钮
    selectedHistoryId: null, // 选中要删除的历史记录ID
    selectedTaskId: null, // 选中要删除的任务ID
    selectedHistoryIndex: -1, // 选中的历史记录索引
    
    // 图片预览相关
    showImagePreview: false, // 是否显示自定义图片预览
    previewImageUrl: '', // 预览的图片URL
    previewSaving: false, // 是否正在保存
    currentPreviewIndex: -1, // 当前预览的图片索引
    skipAutoScroll: false, // 跳过自动滚动到底部
    savedScrollTop: 0, // 保存的滚动位置
    savedTargetPosition: 0, // 预先保存的目标位置
    
    // 上传作品相关
    showUploadModal: false, // 是否显示上传作品弹窗
    uploadImagePath: '', // 上传的图片路径
    uploadData: {
      title: '',
      prompt: '',
      style: ''
    },
    uploading: false, // 是否正在上传
    canSubmitUpload: false, // 是否可以提交
    
    // 图片缩放相关
    imageScale: 1, // 图片缩放比例
    imageTranslateX: 0, // 图片X轴偏移
    imageTranslateY: 0, // 图片Y轴偏移
    lastTouchTime: 0, // 上次点击时间，用于双击检测
    
    // 触摸相关
    touchStartTime: 0,
    touchStartDistance: 0,
    lastTouchX: 0,
    lastTouchY: 0,
    isDragging: false,

    // 滚动状态管理（使用本地存储）
    currentScrollTop: 0,
    // 存储键名
    STORAGE_KEY_SCROLL_STATE: 'ai_generate_scroll_state',
    
    // 强制滚动占位空间相关
    forceScrollPadding: false, // 是否添加占位空间
    forceScrollPaddingHeight: 0 // 占位空间高度（px）
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    const { exampleId, prompt } = options;
    
    // 引入图标工具函数
    const { getIconUrl } = require('../../utils/imageUtils.js');
    
    // 设置图标URLs
    this.setData({
      sendIconUrl: getIconUrl('send.png')
    });
    
    // 初始化滚动重试计数器，防止无限循环
    this.scrollRetryCount = 0;
    
    // 对prompt进行URL解码
    let decodedPrompt = '';
    if (prompt) {
      try {
        decodedPrompt = decodeURIComponent(prompt);
      } catch (e) {
        console.error('解码prompt失败:', e);
        decodedPrompt = prompt; // 解码失败时使用原始值
      }
    }
    
    this.setData({
      exampleId: exampleId ? parseInt(exampleId) : null,
      originalPrompt: decodedPrompt,
      inputPrompt: decodedPrompt,
      hasContent: decodedPrompt && decodedPrompt.trim() !== ''
    });
    
    // 加载历史记录（滚动逻辑交给onShow处理）
    this.loadHistory();
    
    // 如果有提示词，自动开始生成
    if (decodedPrompt) {
      this.startGeneration();
    }
  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {
    console.log('=== onShow 开始 ===');
    
    // 检查是否有从预览返回的标记（使用本地存储）
    const isFromPreview = wx.getStorageSync('ai_generate_from_preview');
    console.log('从本地存储读取isFromPreview:', isFromPreview);
    
    // 加载历史记录
    this.loadHistory().then(() => {
      // 调试接口可能未授权，先跳过，避免401影响渲染
      // this.debugUserRecords();
      
      // 判断滚动行为
      if (isFromPreview) {
        console.log('onShow - 检测到从预览返回，尝试恢复滚动位置');
        // 清除标记
        wx.removeStorageSync('ai_generate_from_preview');
        this.restoreScrollPosition();
      } else {
        // 取消一切自动滚动：直接依赖列表排序达到“进入即最新”的效果
        console.log('onShow - 正常进入/首次进入：不自动滚动，依赖数据排序显示最新');
        this.clearScrollState();
      }
    });
  },

  /**
   * 提示词输入
   */
  onPromptInput(e) {
    const newPrompt = e.detail.value;
    const hasContent = newPrompt.trim() !== '';
    this.setData({
      inputPrompt: newPrompt,
      hasContent: hasContent
    });
  },

  /**
   * 切换提示词展开状态
   */
  togglePromptExpanded() {
    this.setData({
      promptExpanded: !this.data.promptExpanded
    });
  },

  /**
   * 加载历史记录
   */
  async loadHistory() {
    try {
      const response = await api.get('/api/ai-image/history', {
        page: 1,
        size: 20 // 增加加载数量
      });
      
      if (response.success) {
        const records = response.data.records || [];
        console.log('加载历史记录成功，数量:', records.length);
        
        // ⚠️ 检查JavaScript长整型精度丢失问题
        if (records.length > 0) {
          const sampleRecord = records[0];
          if (sampleRecord.id && String(sampleRecord.id).length >= 16) {
            console.warn('⚠️ 检测到长整型ID，JavaScript数字精度可能丢失！');
            console.warn('   建议后端返回ID的字符串格式，或使用UUID作为主要标识');
            console.warn('   当前使用UUID避免精度问题:', sampleRecord.taskId);
          }
        }
        
        console.log('历史记录数据:', records);
        
        // 检查后端实际排序：create_time为null时按ID升序返回（最旧在前）
        console.log('=== 检查后端返回的记录顺序 ===');
        if (records.length > 1) {
          const first = records[0];
          const last = records[records.length - 1];
          console.log('第一条记录ID:', first.id, 'UUID:', first.imageUrl?.match(/generated-images\/([^/_]+?)_/)?.[1]);
          console.log('最后一条记录ID:', last.id, 'UUID:', last.imageUrl?.match(/generated-images\/([^/_]+?)_/)?.[1]);
          
          // 判断实际排序方向
          const firstIdStr = String(first.id);
          const lastIdStr = String(last.id);
          if (firstIdStr.length === lastIdStr.length) {
            if (firstIdStr < lastIdStr) {
              console.log('🔍 后端实际按ID升序返回（最新在底部）');
            } else {
              console.log('🔍 后端实际按ID降序返回（最新在顶部）');
            }
          }
        }
        console.log('=== 后端顺序检查完成 ===');
        
        const formattedRecords = records.map((item, index) => {
          console.log(`历史记录 ${index}:`, item);
          
          // ⚠️ JavaScript长整型精度问题处理
          // 由于19位ID超过JS安全整数范围，使用UUID作为主要标识
          const originalIdStr = String(item.id); // 保留显示用（但可能有精度丢失）
          
          // 提取图片UUID作为稳定标识（避免长整型ID精度丢失）
          const extractUuid = (url) => {
            if (typeof url !== 'string') return null;
            const m = url.match(/generated-images\/([^/_]+?)_/);
            return m && m[1] ? m[1] : null;
          };
          const imageUrls = item.imageUrls && item.imageUrls.length > 0 ? item.imageUrls : (item.imageUrl ? [item.imageUrl] : []);
          const primaryUuid = imageUrls.length > 0 ? extractUuid(imageUrls[0]) : null;
          
          // 如果检测到ID精度丢失，记录警告
          if (originalIdStr.length >= 16 && originalIdStr.endsWith('00')) {
            console.warn(`⚠️ 记录${index}的ID可能有精度丢失: ${originalIdStr} (末尾00可能是精度丢失)`);
            console.warn(`   使用UUID作为可靠标识: ${primaryUuid || item.taskId}`);
          }
          
          return {
            ...item,
            // ⚠️ ID显示问题说明：
            // - item.id 已被JavaScript自动转换，精度丢失（19位→16位有效数字）
            // - 这是JavaScript Number类型的固有限制，无法在前端完美修复
            // - 根本解决方案：后端API返回ID字符串格式 (Long → String)
            // - 当前方案：使用UUID作为稳定标识，ID仅供显示参考
            
            // 用于渲染稳定性与定位（优先使用UUID，避免长整型ID精度问题）
            uniqueKey: primaryUuid || String(item.id ?? item.taskId ?? index),
            stableId: primaryUuid || String(item.id ?? item.taskId ?? index),
            primaryImageUuid: primaryUuid,
            originalIdDisplay: originalIdStr, // 显示用（可能有精度丢失）
            createTimeFormatted: this.formatDate(item.createTime),
            imageUrls: imageUrls,
            // 添加一些展示用的字段
            categoryName: '人像写真', // 可以根据实际情况调整
            modelName: '图片4.0'     // 可以根据实际情况调整
          };
        });
        
        console.log('格式化后的历史记录:', formattedRecords);
        
        // 📋 JavaScript长整型精度问题总结：
        console.log('=== JavaScript数字精度限制说明 ===');
        console.log('问题：19位Long ID超过JavaScript安全整数范围(2^53-1)');
        console.log('现象：末尾数字被舍入，如 1968651218209329153 → 1968651218209329200');
        console.log('影响：ID精度丢失，但不影响功能（已使用UUID作为主要标识）');
        console.log('解决：建议后端返回ID字符串格式，避免JSON解析时自动转换为number');
        console.log('=== 当前使用UUID确保功能正常 ===');
        
        // 设置列表并在首次进入时显示最新记录（由于create_time为null，实际按ID升序返回，最新在底部）
        const enterFromPreview = !!wx.getStorageSync('ai_generate_from_preview');
        this.setData({
          historyList: formattedRecords
        }, () => {
          console.log('loadHistory - 数据设置完成，记录数量:', formattedRecords.length);
          if (!enterFromPreview && formattedRecords.length > 0) {
            // 首次/正常进入：后端实际按ID升序返回，最新记录在最后一条
            const lastIndex = formattedRecords.length - 1;
            const lastId = `history-${lastIndex}`;
            console.log('首次进入：无动画定位到最新记录（底部）', lastId, '记录:', formattedRecords[lastIndex]?.prompt);
            this.setData({ 
              scrollIntoView: lastId,
              scrollWithAnimation: false 
            });
            setTimeout(() => {
              this.setData({ scrollIntoView: '', scrollWithAnimation: true });
            }, 100);
            
            // 确保最新记录可见：如需要则添加底部占位空间
            wx.createSelectorQuery().in(this)
              .select('.history-scroll-view').boundingClientRect()
              .select('.history-cards-container').boundingClientRect()
              .exec((res) => {
                const sv = res && res[0];
                const cc = res && res[1];
                if (sv && cc && cc.height <= sv.height) {
                  const need = sv.height - cc.height + 50;
                  console.log('内容高度不足，添加底部占位确保最新记录可见:', need + 'px');
                  this.setData({
                    forceScrollPadding: true,
                    forceScrollPaddingHeight: Math.ceil(need)
                  });
                  setTimeout(() => {
                    this.setData({ scrollWithAnimation: false, scrollIntoView: lastId });
                    setTimeout(() => {
                      this.setData({ scrollIntoView: '', scrollWithAnimation: true });
                    }, 100);
                  }, 200);
                }
              });
          }
        });
        
        wx.nextTick(() => {
          // 优先返回到最近查看的记录
          if (this.data.lastViewedHistoryIndex >= 0 && this.data.lastViewedHistoryIndex < this.data.historyList.length) {
            console.log('loadHistory后定位到最近查看记录:', this.data.lastViewedHistoryIndex);
            this.scrollToHistoryIndex(this.data.lastViewedHistoryIndex);
          }
          // 其他情况由onLoad和onShow方法控制滚动
        });
        
        console.log('设置后的historyList长度:', this.data.historyList.length);
        console.log('当前页面状态:', {
          generating: this.data.generating,
          generatedImagesLength: this.data.generatedImages.length,
          historyListLength: this.data.historyList.length
        });
      } else {
        console.error('加载历史记录失败:', response.message);
      }
    } catch (error) {
      console.error('加载历史记录失败:', error);
    }
  },

  /**
   * 切换历史记录显示
   */
  toggleHistory() {
    this.setData({
      showHistory: !this.data.showHistory
    });
  },

  /**
   * 切换尺寸选择器
   */
  toggleSizeSelector() {
    this.setData({
      showSizeSelector: !this.data.showSizeSelector
    });
  },

  /**
   * 选择尺寸
   */
  onSizeSelect(e) {
    const index = e.detail.value;
    const selectedOption = this.data.sizeOptions[index];
    
    this.setData({
      selectedSize: selectedOption.value,
      selectedSizeLabel: selectedOption.value,
      showSizeSelector: false
    });
  },

  /**
   * 点击选择尺寸
   */
  selectSize(e) {
    const { size, label } = e.currentTarget.dataset;
    
    console.log('选择尺寸:', size, label);
    
    this.setData({
      selectedSize: size,
      selectedSizeLabel: label || size,
      showSizeSelector: false
    });
    
    wx.showToast({
      title: `已选择 ${label || size}`,
      icon: 'success',
      duration: 1000
    });
  },

  /**
   * 切换模型选择器
   */
  toggleModelSelector() {
    this.setData({
      showModelSelector: !this.data.showModelSelector
    });
  },

  /**
   * 选择模型
   */
  onModelSelect(e) {
    const index = e.detail.value;
    const selectedOption = this.data.modelOptions[index];
    
    this.setData({
      selectedModel: selectedOption.value,
      showModelSelector: false
    });
  },

  /**
   * 开始生成
   */
  async startGeneration() {
    const prompt = this.data.inputPrompt || this.data.originalPrompt;
    const { selectedSize, selectedModel } = this.data;
    
    if (!prompt.trim()) {
      wx.showToast({
        title: '请输入提示词',
        icon: 'none'
      });
      return;
    }

    // 检查积分是否足够
    const creditsRequired = await this.getAiImageCreditsCost();
    if (!await this.checkAndConsumeCredits(creditsRequired, prompt)) {
      return;
    }
    
    // 先设置生成状态，显示占位框
    this.setData({ 
      originalPrompt: prompt,
      inputPrompt: '', // 清空聊天框
      hasContent: false, // 清空聊天框后重置内容状态
      generating: true,
      progress: 0,
      generatedImages: [] // 清空之前的图片，显示占位框
    });
    
    // 滚动到生成卡片
    setTimeout(() => {
      console.log('开始生成 - 滚动到生成卡片');
      this.setData({
        scrollIntoView: 'genCard'
      });
      
      // 清理scroll-into-view
      setTimeout(() => {
        this.setData({ scrollIntoView: '' });
      }, 1000);
    }, 100);
    
    console.log('开始生成流程，当前状态:', {
      generating: this.data.generating,
      progress: this.data.progress,
      generatedImagesLength: this.data.generatedImages.length
    });
    
    // 使用 wx.nextTick 确保界面更新后再继续
    wx.nextTick(async () => {
      console.log('界面已更新，开始进度动画');
      
      // 先显示进度动画
      await this.simulateProgress();
      
      console.log('进度完成，开始请求接口');
      try {
        // 准备请求参数
        const requestData = {
          prompt: prompt,
          size: selectedSize,
        model: selectedModel,
        // 🎨 启用组图功能：生成多张有差异的图片
        sequential_image_generation: "auto", // 自动判断模式
        sequential_image_generation_options: {
          max_images: 3  // 最多生成3张不同的图片
        }
      };
      
      console.log('🎨 已启用组图功能，将生成最多3张有差异的图片');
        
        // 如果有参考图，添加到请求参数中
        if (this.data.referenceImage && this.data.referenceImage.serverUrl) {
          requestData.referenceImagePath = this.data.referenceImage.serverUrl;
          console.log('包含参考图:', this.data.referenceImage.serverUrl);
        }
      
      console.log('📤 发送请求参数:', requestData);
        
        const response = await api.post('/api/ai-image/generate', requestData);
        
        if (response.success) {
          const taskId = response.data.taskId;
          const { imageUrls, imageUrl } = response.data;
          
          this.setData({ currentTaskId: taskId });
          
          // 获得图片后直接显示
          if (imageUrls && imageUrls.length > 0) {
            console.log('🎨 组图生成成功！获得', imageUrls.length, '张不同图片:', imageUrls);
            // 验证图片是否真的不同（检查URL的差异）
            const uniqueUrls = [...new Set(imageUrls)];
            if (uniqueUrls.length === imageUrls.length) {
              console.log('✅ 确认：', imageUrls.length, '张图片都是不同的（URL唯一）');
            } else {
              console.warn('⚠️ 发现重复图片：原始', imageUrls.length, '张，唯一', uniqueUrls.length, '张');
            }
            this.showImagesWithAnimation(imageUrls);
          } else if (imageUrl) {
            console.log('获得单张图片:', imageUrl);
            this.showImagesWithAnimation([imageUrl]);
          } else {
            await this.pollGenerationStatus(taskId);
          }
        } else {
          throw new Error(response.message || '生成请求失败');
        }
      } catch (error) {
        console.error('生成失败:', error);
        wx.showToast({
          title: error.message || '生成失败',
          icon: 'error'
        });
        this.setData({ generating: false });
      }
    });
  },

  /**
   * 显示图片选择器
   */
  showImagePicker() {
    wx.chooseMedia({
      count: 1,
      mediaType: ['image'],
      sourceType: ['album', 'camera'],
      sizeType: ['compressed'],
      success: (res) => {
        if (res.tempFiles && res.tempFiles.length > 0) {
          const file = res.tempFiles[0];
          
          // 检查文件大小 (5MB)
          if (file.size > 5 * 1024 * 1024) {
            wx.showToast({
              title: '图片大小不能超过5MB',
              icon: 'none'
            });
            return;
          }
          
          // 先上传参考图到服务器
          wx.showLoading({ title: '上传参考图中...' });
          
          this.uploadReferenceImage(file.tempFilePath).then(serverImageUrl => {
            wx.hideLoading();
            
            // 保存参考图信息
            this.setData({
              referenceImage: {
                path: file.tempFilePath,
                url: file.tempFilePath,
                serverUrl: serverImageUrl,
                size: file.size
              },
              showReferenceImage: true
            });
            
            wx.showToast({
              title: '参考图已添加',
              icon: 'success',
              duration: 1500
            });
            
            console.log('参考图已上传到服务器:', serverImageUrl);
          }).catch(error => {
            wx.hideLoading();
            console.error('上传参考图失败:', error);
            wx.showToast({
              title: '参考图上传失败',
              icon: 'none'
            });
          });
        }
      },
      fail: (err) => {
        console.error('选择图片失败:', err);
        wx.showToast({
          title: '选择图片失败',
          icon: 'none'
        });
      }
    });
  },

  /**
   * 上传参考图到服务器
   */
  uploadReferenceImage(tempFilePath) {
    return new Promise((resolve, reject) => {
      wx.uploadFile({
        url: config.API_BASE_URL + '/api/ai-image/upload-reference',
        filePath: tempFilePath,
        name: 'image',
        header: {
          'Authorization': `Bearer ${wx.getStorageSync('token')}`
        },
        success: (res) => {
          try {
            const response = JSON.parse(res.data);
            if (response.success) {
              resolve(response.data.imageUrl);
            } else {
              reject(new Error(response.message || '上传失败'));
            }
          } catch (error) {
            reject(new Error('解析响应失败'));
          }
        },
        fail: (error) => {
          reject(error);
        }
      });
    });
  },

  /**
   * 删除参考图
   */
  removeReferenceImage() {
    this.setData({
      referenceImage: null,
      showReferenceImage: false
    });
    
    wx.showToast({
      title: '参考图已移除',
      icon: 'success',
      duration: 1500
    });
  },

  /**
   * 预览参考图（使用自定义预览界面，包含保存和发布功能）
   */
  previewReferenceImage() {
    if (this.data.referenceImage && this.data.referenceImage.url) {
      console.log('预览参考图:', this.data.referenceImage.url);
      
      // 使用自定义预览界面（有保存和发布按钮）
      this.previewHistoryImage({ 
        currentTarget: { 
          dataset: { 
            url: this.data.referenceImage.url, 
            index: 0 
          } 
        } 
      });
    }
  },

  /**
   * 预览参考图（仅查看，无操作按钮）
   */
  previewReferenceImageOnly(e) {
    const url = e.currentTarget.dataset.url;
    if (!url) return;
    
    console.log('预览参考图（仅查看）:', url);
    
    // 使用微信内置的图片预览功能，简洁无按钮
    wx.previewImage({
      current: url,
      urls: [url],
      fail: (err) => {
        console.error('预览参考图失败:', err);
        wx.showToast({
          title: '预览失败',
          icon: 'none'
        });
      }
    });
  },

  /**
   * 模拟进度（独立的进度动画）
   */
  async simulateProgress() {
    console.log('开始进度动画');
    
    // 确保初始状态
    this.setData({ progress: 0, generating: true });
    await new Promise(resolve => setTimeout(resolve, 100));
    
    // 分阶段推进进度，让用户能看到变化
    const progressSteps = [10, 25, 45, 60, 75, 85, 95, 100];
    
    for (let i = 0; i < progressSteps.length; i++) {
      const progress = progressSteps[i];
      this.setData({ progress });
      console.log('进度更新:', progress + '%', '生成状态:', this.data.generating);
      
      // 最后一步不需要等待
      if (i < progressSteps.length - 1) {
        await new Promise(resolve => setTimeout(resolve, 400));
      }
    }
    
    console.log('进度动画完成: 100%');
  },

  /**
   * 轮询生成状态
   */
  async pollGenerationStatus(taskId) {
    let attempts = 0;
    const maxAttempts = 60;
    
    const checkStatus = async () => {
      try {
        attempts++;
        // 更真实的进度增长：前期快速，后期缓慢
        let progress;
        if (attempts <= 5) {
          progress = attempts * 15; // 前5次：0% -> 75%
        } else {
          progress = 75 + (attempts - 5) * 2; // 后面缓慢增长到95%
        }
        progress = Math.min(progress, 95);
        this.setData({ progress });
        console.log('更新进度:', progress, '生成状态:', this.data.generating);
        
        const response = await api.get(`/api/ai-image/status/${taskId}`);
        
        if (response.success) {
          const { status, statusString, imageUrl, imageUrls } = response.data;
          
          // 优先使用statusString，fallback到数字状态码
          const currentStatus = statusString || (status === 1 ? 'completed' : status === 0 ? 'processing' : 'failed');
          
          if (currentStatus === 'completed') {
            // 处理多张图片：优先使用imageUrls，fallback到单张imageUrl
            let finalImages = [];
            if (imageUrls && imageUrls.length > 0) {
              finalImages = imageUrls;
              console.log('🎨 轮询完成：组图生成成功！获得', imageUrls.length, '张图片:', imageUrls);
              // 验证图片是否真的不同
              const uniqueUrls = [...new Set(imageUrls)];
              if (uniqueUrls.length === imageUrls.length) {
                console.log('✅ 确认：', imageUrls.length, '张图片都是不同的（URL唯一）');
              } else {
                console.warn('⚠️ 发现重复图片：原始', imageUrls.length, '张，唯一', uniqueUrls.length, '张');
              }
            } else if (imageUrl) {
              finalImages = [imageUrl];
              console.log('轮询完成：获得单张图片:', imageUrl);
            }
            
            console.log('生成完成，图片数量:', finalImages.length, '图片URLs:', finalImages);
            
            // 生成完成，触发动画效果
            this.setData({
              generating: false,
              progress: 100
            });
            
            // 逐张显示图片，创造更好的视觉效果
            this.showImagesWithAnimation(finalImages);
            
            // 刷新历史记录
            this.loadHistory();
            
            // 如果有exampleId，询问是否发布到社区
            if (this.data.exampleId) {
              this.showPublishDialog();
            }
            
          } else if (currentStatus === 'failed') {
            throw new Error('图片生成失败');
          } else if (attempts >= maxAttempts) {
            throw new Error('生成超时，请稍后重试');
          } else {
            setTimeout(checkStatus, 2000);
          }
        } else {
          if (attempts >= maxAttempts) {
            throw new Error('查询状态失败');
          } else {
            setTimeout(checkStatus, 2000);
          }
        }
      } catch (error) {
        console.error('查询状态失败:', error);
        this.setData({ generating: false });
        wx.showToast({
          title: error.message || '生成失败',
          icon: 'error'
        });
      }
    };
    
    checkStatus();
  },

  /**
   * 显示发布对话框
   */
  showPublishDialog() {
    wx.showModal({
      title: '生成完成',
      content: '是否将此作品发布到示例图社区？',
      confirmText: '发布',
      cancelText: '稍后',
      success: async (res) => {
        if (res.confirm && this.data.generatedImages.length > 0) {
          await this.publishToExample();
        }
      }
    });
  },

  /**
   * 发布到示例图社区
   */
  async publishToExample() {
    const { exampleId, prompt, selectedSize, generatedImages } = this.data;
    
    try {
      const request = {
        imageUrl: generatedImages[this.data.currentImageIndex].url,
        prompt: prompt,
        style: '创意',
        size: selectedSize
      };
      
      const response = await api.post(`/api/ai-image/examples/${exampleId}/chat`, request);
      
      if (response.success) {
        wx.showToast({
          title: '发布成功',
          icon: 'success'
        });
      }
    } catch (error) {
      console.error('发布失败:', error);
      wx.showToast({
        title: '发布失败',
        icon: 'error'
      });
    }
  },

  /**
   * 重新生成
   */
  regenerate() {
    this.startGeneration();
  },

  /**
   * 格式化日期显示
   */
  formatDate(dateString) {
    if (!dateString) return '';
    
    const date = new Date(dateString);
    const now = new Date();
    const diff = now.getTime() - date.getTime();
    
    // 小于1分钟
    if (diff < 60 * 1000) {
      return '刚刚';
    }
    // 小于1小时
    if (diff < 60 * 60 * 1000) {
      const minutes = Math.floor(diff / (60 * 1000));
      return `${minutes}分钟前`;
    }
    // 小于1天
    if (diff < 24 * 60 * 60 * 1000) {
      const hours = Math.floor(diff / (60 * 60 * 1000));
      return `${hours}小时前`;
    }
    // 小于7天
    if (diff < 7 * 24 * 60 * 60 * 1000) {
      const days = Math.floor(diff / (24 * 60 * 60 * 1000));
      return `${days}天前`;
    }
    // 超过7天显示具体日期
    const month = date.getMonth() + 1;
    const day = date.getDate();
    return `${month}月${day}日`;
  },


  /**
   * 重用提示词
   */
  reusePrompt(e) {
    const prompt = e.currentTarget.dataset.prompt;
    if (!prompt) return;
    
    this.setData({
      inputPrompt: prompt
    });
    
    wx.showToast({
      title: '提示词已填入',
      icon: 'success',
      duration: 1500
    });
  },

  /**
   * 从历史记录直接生成图片
   */
  regenerateFromHistory(e) {
    const prompt = e.currentTarget.dataset.prompt;
    if (!prompt) {
      wx.showToast({
        title: '提示词为空',
        icon: 'none'
      });
      return;
    }
    
    // 设置提示词并开始生成
    this.setData({
      inputPrompt: prompt,
      originalPrompt: prompt
    });
    
    // 开始生成
    this.startGeneration();
  },

  /**
   * 监听scroll-view滚动事件
   */
  onScrollViewScroll(e) {
    // 实时记录滚动位置
    this.setData({
      currentScrollTop: e.detail.scrollTop
    });
    
    // 节流保存滚动状态（避免频繁存储）
    if (this.scrollSaveTimer) {
      clearTimeout(this.scrollSaveTimer);
    }
    
    this.scrollSaveTimer = setTimeout(() => {
      this.saveScrollStateAsync();
    }, 500); // 500ms后保存
  },

  /**
   * 异步保存滚动状态
   */
  async saveScrollStateAsync() {
    try {
      const visibleItems = await this.getVisibleHistoryItems();
      const scrollState = {
        scrollTop: this.data.currentScrollTop,
        timestamp: Date.now(),
        historyListLength: this.data.historyList?.length || 0,
        visibleItems: visibleItems
      };
      
      console.log('异步保存滚动状态:', scrollState);
      wx.setStorageSync(this.data.STORAGE_KEY_SCROLL_STATE, scrollState);
    } catch (error) {
      console.error('保存滚动状态失败:', error);
    }
  },

  /**
   * 预览历史图片（自定义预览界面）
   */
  previewHistoryImage(e) {
    const url = e.currentTarget.dataset.url;
    const index = e.currentTarget.dataset.index;
    const id = e.currentTarget.dataset.id;
    const taskId = e.currentTarget.dataset.taskId;
    if (!url) return;
    
    console.log('=== 预览图片 ===');
    console.log('预览索引:', index, '当前滚动位置:', this.data.currentScrollTop);
    
    // 强制更新当前滚动位置
    wx.createSelectorQuery().in(this)
      .select('.history-scroll-view')
      .scrollOffset()
      .exec((res) => {
        const scrollInfo = res[0];
        if (scrollInfo) {
          console.log('预览前实际滚动位置:', scrollInfo.scrollTop);
      this.setData({ 
            currentScrollTop: scrollInfo.scrollTop
          });
        }
        
        // 保存当前滚动状态到本地存储（在预览前）
        this.saveScrollStateAsync();
      });
    
    // 设置预览返回标记到本地存储，并保存点击的记录索引/ID
    wx.setStorageSync('ai_generate_from_preview', true);
    wx.setStorageSync('ai_generate_preview_target_index', index);
    if (id) wx.setStorageSync('ai_generate_preview_target_id', String(id));
    if (taskId) wx.setStorageSync('ai_generate_preview_target_task_id', String(taskId));
    // 提取被点击图片的UUID（如 /generated-images/<uuid>_1.jpg）
    if (typeof url === 'string') {
      const m = url.match(/generated-images\/([^/_]+?)_/);
      if (m && m[1]) {
        wx.setStorageSync('ai_generate_preview_target_img_uuid', m[1]);
        console.log('保存预览图片UUID:', m[1]);
      }
    }
    console.log('设置预览返回标记到本地存储');
    
    // 禁用页面滚动
    this.disablePageScroll();
    
    // 显示自定义图片预览
    this.setData({
      showImagePreview: true,
      previewImageUrl: url,
      currentPreviewIndex: parseInt(index)
    });
  },

  /**
   * 关闭图片预览
   */
  closeImagePreview() {
    console.log('=== 关闭图片预览 ===');
    console.log('预览返回标记已设置，等待onShow恢复位置');
    
    // 启用页面滚动
    this.enablePageScroll();
    
    // 重置预览相关状态
    this.setData({
      showImagePreview: false,
      previewImageUrl: '',
      previewSaving: false,
      currentPreviewIndex: -1,
      imageScale: 1,
      imageTranslateX: 0,
      imageTranslateY: 0,
      lastTouchTime: 0,
      touchStartTime: 0,
      touchStartDistance: 0,
      lastTouchX: 0,
      lastTouchY: 0,
      isDragging: false
    });
    
    // 滚动位置恢复完全交给onShow处理
    // ai_generate_from_preview 标记已经设置在本地存储中
  },

  /**
   * 恢复滚动位置（基于本地存储的状态）
   */
  restoreScrollPosition() {
    const scrollState = this.getScrollState();
    let previewTargetIndex = wx.getStorageSync('ai_generate_preview_target_index');
    const previewTargetId = wx.getStorageSync('ai_generate_preview_target_id');
    const previewTargetTaskId = wx.getStorageSync('ai_generate_preview_target_task_id');
    const previewTargetImgUuid = wx.getStorageSync('ai_generate_preview_target_img_uuid');
    
    if (!scrollState) {
      console.log('没有保存的滚动状态，滚动到最新记录');
      setTimeout(() => {
        // 后端实际按ID升序返回，最新记录在最后一条
        if (this.data.historyList.length > 0) {
          const lastIndex = this.data.historyList.length - 1;
          const lastId = `history-${lastIndex}`;
          this.setData({ 
            scrollWithAnimation: false,
            scrollIntoView: lastId 
          });
          setTimeout(() => {
            this.setData({ scrollIntoView: '', scrollWithAnimation: true });
          }, 100);
        }
      }, 300);
      return;
    }
    
    console.log('恢复滚动位置，状态:', scrollState);
    
    // 方法0：优先使用UUID匹配（最可靠，避免长整型ID精度问题）
    if (previewTargetImgUuid) {
      const uuid = String(previewTargetImgUuid);
      const foundIndex = this.data.historyList.findIndex(it => {
        return it.primaryImageUuid === uuid || (it.imageUrls || []).some(u => typeof u === 'string' && u.includes(uuid));
      });
      if (foundIndex >= 0) {
        const id = `history-${foundIndex}`;
        console.log('根据预览返回（图片UUID）精确定位到:', id, 'uuid:', uuid);
        this.setData({ scrollWithAnimation: false, scrollIntoView: id });
        setTimeout(() => {
          this.setData({ scrollIntoView: '', scrollWithAnimation: true });
          wx.removeStorageSync('ai_generate_preview_target_img_uuid');
          wx.removeStorageSync('ai_generate_preview_target_id');
          wx.removeStorageSync('ai_generate_preview_target_task_id');
          wx.removeStorageSync('ai_generate_preview_target_index');
        }, 100);
        return;
      }
    }
    
    // 方法1：回退到ID/taskId匹配（但由于精度问题可能不准确）
    if (previewTargetId || previewTargetTaskId) {
      console.log('⚠️ UUID匹配失败，尝试ID匹配（可能不准确）');
      const foundIndex = this.data.historyList.findIndex(it => {
        const sid = String(it.id);
        const stask = String(it.taskId);
        return (previewTargetId && sid === String(previewTargetId)) || (previewTargetTaskId && stask === String(previewTargetTaskId));
      });
      if (foundIndex >= 0) {
        const id = `history-${foundIndex}`;
        console.log('根据预览返回（ID）精确定位到:', id);
        this.setData({ scrollWithAnimation: false, scrollIntoView: id });
        setTimeout(() => {
          this.setData({ scrollIntoView: '', scrollWithAnimation: true });
          wx.removeStorageSync('ai_generate_preview_target_id');
          wx.removeStorageSync('ai_generate_preview_target_task_id');
          wx.removeStorageSync('ai_generate_preview_target_index');
        }, 100);
        return;
      }
    }


    // 最后回退：使用索引（但可能因排序变化而不准确）
    if (typeof previewTargetIndex === 'number' && previewTargetIndex >= 0 && previewTargetIndex < this.data.historyList.length) {
      console.log('⚠️ UUID和ID匹配都失败，尝试索引定位（可能不准确）');
      const id = `history-${previewTargetIndex}`;
      console.log('根据预览返回（索引）定位到:', id);
      this.setData({ scrollWithAnimation: false, scrollIntoView: id });
    setTimeout(() => {
        this.setData({ scrollIntoView: '', scrollWithAnimation: true });
        wx.removeStorageSync('ai_generate_preview_target_index');
    }, 100);
      return;
    }

    // 方法2：尝试恢复到可见项目（基于scrollTop和visibleItems）
    if (scrollState.visibleItems && scrollState.visibleItems.length > 0) {
      const firstVisibleItem = scrollState.visibleItems[0];
      console.log('尝试恢复到可见项目:', firstVisibleItem);
      
      // 在当前历史记录中查找对应项目
    setTimeout(() => {
        this.restoreToVisibleItem(firstVisibleItem);
      }, 200);
        return;
    }
    
    // 方法3：回退方案 - 使用保存的scrollTop（可能不准确）
    if (scrollState.scrollTop !== undefined && scrollState.scrollTop > 0) {
      console.log('使用保存的scrollTop恢复位置:', scrollState.scrollTop);
        setTimeout(() => {
        this.setData({ 
          scrollTop: scrollState.scrollTop
        });
      }, 200);
                  } else {
      console.log('所有恢复方法都失败，滚动到最新记录');
      setTimeout(() => {
        // 滚动到最后一条（最新记录，后端实际按ID升序）
        if (this.data.historyList.length > 0) {
          const lastIndex = this.data.historyList.length - 1;
          const lastId = `history-${lastIndex}`;
          this.setData({ 
            scrollWithAnimation: false, 
            scrollIntoView: lastId 
          });
          setTimeout(() => {
            this.setData({ scrollIntoView: '', scrollWithAnimation: true });
          }, 100);
        }
      }, 300);
    }
  },

  /**
   * 恢复到特定的可见项目
   */
  restoreToVisibleItem(targetItem) {
    if (!this.data.historyList || this.data.historyList.length === 0) {
      return;
    }
    
    // 查找目标项目在当前列表中的位置
    const currentIndex = this.data.historyList.findIndex(item => item.id === targetItem.id);
    
    if (currentIndex >= 0) {
      console.log('找到目标项目，索引:', currentIndex, '原索引:', targetItem.index);
      
      // 使用scroll-into-view精确滚动到目标项目
      const targetId = `history-${currentIndex}`;
    this.setData({ 
      scrollIntoView: targetId 
    });
    
    setTimeout(() => {
      this.setData({ scrollIntoView: '' });
      }, 800);
      
    } else {
      console.log('未找到目标项目，使用保存的scrollTop');
      // 如果找不到具体项目，还是使用scrollTop
      const scrollState = this.getScrollState();
      if (scrollState && scrollState.scrollTop !== undefined) {
      this.setData({ 
          scrollTop: scrollState.scrollTop
      });
      }
    }
  },


  /**
   * 预览界面的保存按钮
   */
  savePreviewImage() {
    if (!this.data.previewImageUrl) return;
    
    this.setData({ previewSaving: true });
    this.saveImageToAlbum(this.data.previewImageUrl);
    
    // 保存完成后重置状态
    setTimeout(() => {
      this.setData({ previewSaving: false });
    }, 2000);
  },

  /**
   * 预览界面的发布按钮
   */
  publishPreviewImage() {
    console.log('点击发布按钮');
    if (!this.data.previewImageUrl) {
      console.log('没有预览图片URL');
      wx.showToast({
        title: '没有可发布的图片',
        icon: 'error'
      });
      return;
    }
    
    // 先保存图片URL，再关闭预览
    const imageUrl = this.data.previewImageUrl;
    console.log('准备发布图片:', imageUrl);
    
    // 关闭预览界面
    this.closeImagePreview();
    // 发布图片
    this.publishImage(imageUrl);
  },

  /**
   * 图片双击放大/缩小
   */
  onImageDoubleTap(e) {
    console.log('双击事件触发');
    const { imageScale } = this.data;
    
    // 双击切换缩放：1倍 <-> 2倍
    const newScale = imageScale === 1 ? 2 : 1;
    
    console.log('切换缩放 - 当前:', imageScale, '新:', newScale);
    
    this.setData({
      imageScale: newScale,
      imageTranslateX: 0,
      imageTranslateY: 0
    });
  },


  /**
   * 计算两点间距离
   */
  getDistance(touch1, touch2) {
    const dx = touch1.clientX - touch2.clientX;
    const dy = touch1.clientY - touch2.clientY;
    return Math.sqrt(dx * dx + dy * dy);
  },

  /**
   * 触摸开始
   */
  onTouchStart(e) {
    const touches = e.touches;
    
    if (touches.length === 1) {
      // 单指触摸，记录位置用于拖拽
      this.setData({
        lastTouchX: touches[0].clientX,
        lastTouchY: touches[0].clientY,
        touchStartTime: Date.now()
      });
    } else if (touches.length === 2) {
      // 双指触摸，记录距离用于缩放
      const distance = this.getDistance(touches[0], touches[1]);
      this.setData({
        touchStartDistance: distance
      });
    }
  },

  /**
   * 触摸移动
   */
  onTouchMove(e) {
    const touches = e.touches;
    
    if (touches.length === 1) {
      // 单指拖拽
      const { lastTouchX, lastTouchY, imageScale, imageTranslateX, imageTranslateY } = this.data;
      
      if (imageScale > 1) {
        const deltaX = touches[0].clientX - lastTouchX;
        const deltaY = touches[0].clientY - lastTouchY;
        
        // 计算新的位移
        let newX = imageTranslateX + deltaX;
        let newY = imageTranslateY + deltaY;
        
        // 限制拖拽范围
        const maxMove = 100 * (imageScale - 1);
        if (newX > maxMove) newX = maxMove;
        if (newX < -maxMove) newX = -maxMove;
        if (newY > maxMove) newY = maxMove;
        if (newY < -maxMove) newY = -maxMove;
        
        this.setData({
          imageTranslateX: newX,
          imageTranslateY: newY,
          lastTouchX: touches[0].clientX,
          lastTouchY: touches[0].clientY,
          isDragging: true
        });
      }
    } else if (touches.length === 2) {
      // 双指缩放
      const { touchStartDistance } = this.data;
      const currentDistance = this.getDistance(touches[0], touches[1]);
      
      if (touchStartDistance > 0) {
        const scaleRatio = currentDistance / touchStartDistance;
        const currentScale = this.data.imageScale;
        let newScale = currentScale * scaleRatio;
        
        // 限制缩放范围
        if (newScale < 0.5) newScale = 0.5;
        if (newScale > 3) newScale = 3;
        
        console.log('双指缩放:', currentScale, '->', newScale);
        
        this.setData({
          imageScale: newScale,
          touchStartDistance: currentDistance
        });
      }
    }
  },

  /**
   * 触摸结束
   */
  onTouchEnd(e) {
    // 重置拖拽状态
    this.setData({
      isDragging: false,
      touchStartDistance: 0
    });
  },

  /**
   * 图片点击处理（双击检测）
   */
  onImageTap(e) {
    const currentTime = Date.now();
    const { lastTouchTime } = this.data;
    
    // 检测双击（两次点击间隔小于500ms）
    if (lastTouchTime && currentTime - lastTouchTime < 500) {
      console.log('检测到双击');
      this.onImageDoubleTap(e);
      // 重置时间，避免连续触发
      this.setData({
        lastTouchTime: 0
      });
    } else {
      // 记录点击时间
      this.setData({
        lastTouchTime: currentTime
      });
    }
  },

  /**
   * 阻止页面滚动
   */
  preventTouchMove(e) {
    // 阻止默认的滚动行为
    e.preventDefault();
    e.stopPropagation();
    return false;
  },

  /**
   * 禁用页面滚动
   */
  disablePageScroll() {
    // 设置页面不可滚动
    wx.pageScrollTo({
      scrollTop: 0,
      duration: 0
    });
  },

  /**
   * 启用页面滚动
   */
  enablePageScroll() {
    // 恢复页面滚动
  },

  /**
   * 滚动到指定的历史记录项
   */
  scrollToHistoryItem(index) {
    console.log('准备滚动到历史记录项:', index);
    
    // 先清空scrollIntoView
    this.setData({
      scrollIntoView: ''
    });
    
    // 延迟设置scrollIntoView到指定的历史记录
    setTimeout(() => {
      console.log('设置scrollIntoView到history-' + index);
      this.setData({
        scrollIntoView: `history-${index}`
      });
    }, 100);
    
    // 延迟清空scrollIntoView，避免影响后续滚动
    setTimeout(() => {
      console.log('清空scrollIntoView');
      this.setData({
        scrollIntoView: ''
      });
    }, 1000);
  },


  /**
   * 历史记录长按事件
   */
  onHistoryLongPress(e) {
    const { id, taskId, index } = e.currentTarget.dataset;
    console.log('长按历史记录:', id, 'taskId:', taskId, 'index:', index);
    console.log('历史记录数据:', this.data.historyList[index]);
    
    // 触发震动反馈
    wx.vibrateShort({
      type: 'medium'
    });
    
    // 显示删除按钮并选中当前记录
    this.setData({
      showDeleteButton: true,
      selectedHistoryId: id,
      selectedTaskId: taskId,
      selectedHistoryIndex: parseInt(index)
    });
  },

  /**
   * 取消删除
   */
  cancelDelete() {
    this.setData({
      showDeleteButton: false,
      selectedHistoryId: null,
      selectedTaskId: null,
      selectedHistoryIndex: -1
    });
  },

  /**
   * 确认删除
   */
  confirmDelete() {
    const { selectedTaskId, selectedHistoryIndex } = this.data;
    
    if (!selectedTaskId) {
      wx.showToast({
        title: '请选择要删除的记录',
        icon: 'error'
      });
      return;
    }

    wx.showModal({
      title: '确认删除',
      content: '删除后无法恢复，确定要删除这条记录吗？',
      confirmText: '删除',
      confirmColor: '#ff3b30',
      success: (res) => {
        if (res.confirm) {
          this.deleteHistoryRecord(selectedTaskId, selectedHistoryIndex);
        }
      }
    });
  },

  /**
   * 删除历史记录
   */
  async deleteHistoryRecord(taskId, recordIndex) {
    try {
      console.log('准备删除记录 taskId:', taskId, '索引:', recordIndex);
      console.log('要删除的记录详情:', this.data.historyList[recordIndex]);
      
      if (!taskId) {
        throw new Error('无效的任务ID: ' + taskId);
      }
      
      wx.showLoading({
        title: '删除中...'
      });

      const response = await api.delete(`/api/ai-image/history/by-task/${taskId}`);
      console.log('删除API响应:', response);
      
      if (response.success) {
        // 从本地数据中移除该记录
        const newHistoryList = this.data.historyList.filter((_, index) => index !== recordIndex);
        
        this.setData({
          historyList: newHistoryList,
          showDeleteButton: false,
          selectedHistoryId: null,
          selectedTaskId: null,
          selectedHistoryIndex: -1
        });
        
        wx.showToast({
          title: '删除成功',
          icon: 'success'
        });
        
        console.log('删除历史记录成功, taskId:', taskId);
      } else {
        throw new Error(response.message || '删除失败');
      }
    } catch (error) {
      console.error('删除历史记录失败:', error);
      console.error('错误详情:', error.response || error);
      wx.showToast({
        title: error.message || '删除失败',
        icon: 'error'
      });
    } finally {
      wx.hideLoading();
    }
  },

  /**
   * 调试：获取用户的实际历史记录ID
   */
  async debugUserRecords() {
    try {
      const response = await api.get('/api/ai-image/debug/user-records');
      console.log('后端实际的历史记录ID列表:', response.data);
      console.log('前端显示的历史记录ID列表:', this.data.historyList.map(item => item.id));
      
      // 比较前后端数据差异
      const backendIds = response.data || [];
      const frontendIds = this.data.historyList.map(item => item.id);
      
      console.log('前端独有的ID:', frontendIds.filter(id => !backendIds.includes(id)));
      console.log('后端独有的ID:', backendIds.filter(id => !frontendIds.includes(id)));
    } catch (error) {
      console.error('调试接口调用失败:', error);
    }
  },

  /**
   * 发布图片到作品
   */
  publishImage(imageUrl) {
    console.log('执行发布图片:', imageUrl);
    console.log('当前inputPrompt:', this.data.inputPrompt);
    console.log('当前originalPrompt:', this.data.originalPrompt);
    
    // 选择最合适的提示词（优先使用originalPrompt，因为它是实际生成时使用的）
    const promptToUse = this.data.originalPrompt || this.data.inputPrompt || '';
    
    // 直接在当前页面打开上传作品弹窗
    this.setData({
      uploadImagePath: imageUrl,
      showUploadModal: true,
      uploadData: {
        title: '',
        prompt: promptToUse, // 预填实际生成时使用的提示词
        style: ''
      }
    }, () => {
      // 设置数据后检查是否可以提交
      console.log('弹窗数据设置完成:');
      console.log('  uploadImagePath:', this.data.uploadImagePath);
      console.log('  showUploadModal:', this.data.showUploadModal);
      console.log('  uploadData:', this.data.uploadData);
      console.log('  使用的提示词:', promptToUse);
      this.checkCanSubmit();
    });
  },

  /**
   * 隐藏上传作品弹窗
   */
  hideUploadModal() {
    this.setData({
      showUploadModal: false,
      uploadImagePath: '',
      uploadData: {
        title: '',
        prompt: '',
        style: ''
      },
      uploading: false,
      canSubmitUpload: false
    });
  },

  /**
   * 选择上传图片
   */
  chooseUploadImage() {
    // 允许重新选择图片
    wx.chooseImage({
      count: 1,
      sizeType: ['compressed'],
      sourceType: ['album', 'camera'],
      success: (res) => {
        const imagePath = res.tempFilePaths[0];
        console.log('用户选择了新图片:', imagePath);
        this.setData({
          uploadImagePath: imagePath
        });
        this.checkCanSubmit();
      }
    });
  },

  /**
   * 标题输入
   */
  onUploadTitleInput(e) {
    this.setData({
      'uploadData.title': e.detail.value
    });
    this.checkCanSubmit();
  },

  /**
   * 提示词输入
   */
  onUploadPromptInput(e) {
    this.setData({
      'uploadData.prompt': e.detail.value
    });
    this.checkCanSubmit();
  },

  /**
   * 风格输入
   */
  onUploadStyleInput(e) {
    this.setData({
      'uploadData.style': e.detail.value
    });
    this.checkCanSubmit();
  },

  /**
   * 检查是否可以提交
   */
  checkCanSubmit() {
    const { uploadData, uploadImagePath } = this.data;
    const canSubmit = uploadImagePath && 
                     uploadData.title.trim() && 
                     uploadData.prompt.trim() && 
                     uploadData.style.trim();
    
    this.setData({
      canSubmitUpload: canSubmit
    });
  },

  /**
   * 提交上传作品
   */
  async submitUpload() {
    if (!this.data.canSubmitUpload || this.data.uploading) {
      wx.showToast({
        title: '请填写完整信息',
        icon: 'error'
      });
      return;
    }

    this.setData({ uploading: true });

    try {
      const { uploadImagePath, uploadData } = this.data;
      
      // 准备上传数据
      const formData = {
        title: uploadData.title,
        prompt: uploadData.prompt,
        style: uploadData.style,
        size: this.data.selectedSize || '1024x1024'
      };
      
      console.log('ai-generate页面上传数据:', formData);
      console.log('图片路径:', uploadImagePath);
      
      let response;
      
      // 判断是本地文件还是网络图片URL
      const isLocalFile = uploadImagePath.startsWith('http://tmp/') || 
                         uploadImagePath.startsWith('wxfile://') ||
                         !uploadImagePath.startsWith('http');
      const isNetworkUrl = !isLocalFile;
      
      console.log('ai-generate URL类型判断:', {
        path: uploadImagePath,
        isTmp: uploadImagePath.startsWith('http://tmp/'),
        isWxfile: uploadImagePath.startsWith('wxfile://'),
        isNotHttp: !uploadImagePath.startsWith('http'),
        isLocalFile: isLocalFile,
        isNetworkUrl: isNetworkUrl
      });
      
      if (isNetworkUrl) {
        console.log('ai-generate: 检测到网络图片URL，使用URL上传方式');
        // 网络图片URL（AI生成的图片）
        const uploadPayload = {
          ...formData,
          imageUrl: uploadImagePath
        };
        response = await api.post('/api/user-upload/example', uploadPayload);
      } else {
        console.log('ai-generate: 检测到本地图片文件，使用文件上传方式');
        // 本地图片文件
        response = await api.uploadExampleFile(uploadImagePath, formData);
      }
      
      if (response.success) {
        wx.showToast({
          title: '发布成功！',
          icon: 'success'
        });
        
        this.hideUploadModal();
      } else {
        throw new Error(response.message || '上传失败');
      }
      
    } catch (error) {
      console.error('上传失败:', error);
      wx.showToast({
        title: error.message || '上传失败，请重试',
        icon: 'error'
      });
    } finally {
      this.setData({ uploading: false });
    }
  },

  /**
   * 保存单张图片到相册
   */
  saveImageToAlbum(imageUrl) {
    wx.showLoading({
      title: '保存中...'
    });

    wx.downloadFile({
      url: imageUrl,
      success: (res) => {
        if (res.statusCode === 200) {
          wx.saveImageToPhotosAlbum({
            filePath: res.tempFilePath,
            success: () => {
              wx.hideLoading();
              wx.showToast({
                title: '保存成功',
                icon: 'success'
              });
            },
            fail: (error) => {
              wx.hideLoading();
              console.error('保存图片失败:', error);
              if (error.errMsg.includes('auth')) {
                wx.showModal({
                  title: '需要授权',
                  content: '需要您授权保存图片到相册',
                  showCancel: false,
                  confirmText: '去设置',
                  success: () => {
                    wx.openSetting();
                  }
                });
              } else {
                wx.showToast({
                  title: '保存失败',
                  icon: 'error'
                });
              }
            }
          });
        } else {
          wx.hideLoading();
          wx.showToast({
            title: '下载失败',
            icon: 'error'
          });
        }
      },
      fail: (error) => {
        wx.hideLoading();
        console.error('下载图片失败:', error);
        wx.showToast({
          title: '下载失败',
          icon: 'error'
        });
      }
    });
  },

  /**
   * 生成完成后直接保存到历史并刷新
   */
  showImagesWithAnimation(imageUrls) {
    console.log('生成完成，图片数量:', imageUrls.length);
    
    // 进度完成，关闭生成状态，清空临时图片
    this.setData({
      generating: false,
      progress: 100,
      generatedImages: [] // 清空临时生成的图片
    });
    
    // 延迟一下让用户看到进度完成，然后刷新历史记录
    setTimeout(() => {
      console.log('刷新历史记录');
      this.loadHistory().then(() => {
        // 生成完成后不做滚动，保持当前位置
        console.log('生成完成 - 不自动滚动，保持当前位置');
      });
      
      // 如果有exampleId，询问是否发布到社区
      if (this.data.exampleId) {
        this.showPublishDialog();
      }
    }, 500);
  },

  /**
   * 预览图片（使用自定义预览界面，包含保存和发布功能）
   */
  previewImage(e) {
    const index = e.currentTarget.dataset.index;
    const currentUrl = this.data.generatedImages[index];
    
    if (!currentUrl) return;
    
    console.log('预览生成图片:', currentUrl);
    
    // 使用自定义预览界面（有保存和发布按钮）
    this.previewHistoryImage({ currentTarget: { dataset: { url: currentUrl, index: index } } });
  },


  /**
   * 分享图片
   */
  shareImage() {
    wx.showToast({
      title: '功能开发中',
      icon: 'none'
    });
  },

  /**
   * 页面卸载时清理
   */
  onUnload() {
    // 清理滚动保存定时器
    if (this.scrollSaveTimer) {
      clearTimeout(this.scrollSaveTimer);
      this.scrollSaveTimer = null;
    }
    
    console.log('页面卸载，清理资源');
  },

  /**
   * 返回上一页
   */
  goBack() {
    wx.navigateBack();
  },

  /**
   * 保存滚动状态到本地存储
   */
  saveScrollState() {
    const scrollState = {
      scrollTop: this.data.currentScrollTop,
      timestamp: Date.now(),
      historyListLength: this.data.historyList?.length || 0,
      // 记录当前可见区域的第一个和最后一个项目ID
      visibleItems: this.getVisibleHistoryItems()
    };
    
    console.log('保存滚动状态:', scrollState);
    wx.setStorageSync(this.data.STORAGE_KEY_SCROLL_STATE, scrollState);
  },

  /**
   * 读取滚动状态从本地存储
   */
  getScrollState() {
    try {
      const scrollState = wx.getStorageSync(this.data.STORAGE_KEY_SCROLL_STATE);
      console.log('读取滚动状态:', scrollState);
      
      // 检查状态是否过期（超过30分钟则认为过期）
      if (scrollState && scrollState.timestamp) {
        const now = Date.now();
        const timeDiff = now - scrollState.timestamp;
        if (timeDiff < 30 * 60 * 1000) {  // 30分钟
          return scrollState;
        } else {
          console.log('滚动状态已过期，清除存储');
          wx.removeStorageSync(this.data.STORAGE_KEY_SCROLL_STATE);
        }
      }
    } catch (error) {
      console.error('读取滚动状态失败:', error);
    }
    return null;
  },

  /**
   * 清除滚动状态
   */
  clearScrollState() {
    console.log('清除滚动状态');
    wx.removeStorageSync(this.data.STORAGE_KEY_SCROLL_STATE);
  },

  /**
   * 获取当前可见的历史记录项目
   */
  getVisibleHistoryItems() {
    return new Promise((resolve) => {
      const query = wx.createSelectorQuery().in(this);
      query.select('.history-scroll-view').boundingClientRect();
      query.selectAll('.history-card').boundingClientRect();
      
      query.exec((res) => {
        if (res && res[0] && res[1]) {
          const container = res[0];
          const cards = res[1];
          
          const visibleItems = [];
          cards.forEach((card, index) => {
            // 判断卡片是否在可视区域内
            if (card.top >= container.top && card.top <= container.bottom) {
              const historyItem = this.data.historyList[index];
              if (historyItem && historyItem.id) {
                visibleItems.push({
                  id: historyItem.id,
                  index: index
                });
              }
            }
          });
          
          console.log('当前可见项目:', visibleItems);
          resolve(visibleItems);
        } else {
          resolve([]);
        }
      });
    });
  },

  /**
   * 强制滚动到顶部显示最新记录（修正版本）
   */
  forceScrollToTop() {
    console.log('=== 强制滚动到顶部 ===');
    console.log('历史记录数量:', this.data.historyList.length);
    
    // 滚动到顶部
    this.setData({ 
      scrollTop: 0,
      scrollIntoView: '' 
    });
    
    console.log('✅ 滚动到顶部完成');
  },

  /**
   * 直接强制滚动到底部（最简化版本）
   */
  forceScrollToBottomDirect() {
    console.log('=== 直接强制滚动到底部 ===');
    console.log('历史记录数量:', this.data.historyList.length);
    
    // 检查是否需要占位空间
    wx.createSelectorQuery().in(this)
      .select('.history-scroll-view').boundingClientRect()
      .select('.history-cards-container').boundingClientRect()
      .exec((res) => {
        const scrollView = res[0];
        const contentContainer = res[1];
        
        console.log('容器高度检查:', {
          scrollViewHeight: scrollView?.height,
          contentHeight: contentContainer?.height
        });
        
        if (scrollView && contentContainer && contentContainer.height <= scrollView.height) {
          const needPadding = scrollView.height - contentContainer.height + 300;
          console.log('⚠️ 内容高度不足，需要占位:', needPadding + 'px');
          
          // 添加足够的占位空间
          this.setData({
            forceScrollPadding: true,
            forceScrollPaddingHeight: needPadding
          });
          
          // 等待渲染后滚动
      setTimeout(() => {
            this.executeDirectScroll();
          }, 600);
        } else {
          console.log('✅ 内容高度足够，直接滚动');
          this.executeDirectScroll();
        }
      });
  },

  /**
   * 执行直接滚动
   */
  executeDirectScroll() {
    console.log('=== 执行直接滚动 ===');
    
    // 多重滚动策略
    // 1. 重置到0
    this.setData({ scrollTop: 0 });
    
    setTimeout(() => {
      // 2. 滚动到巨大数值
      console.log('设置scrollTop到巨大数值');
      this.setData({ scrollTop: 999999 });
    }, 100);
    
    setTimeout(() => {
      // 3. 使用锚点滚动
      console.log('使用锚点滚动到底部');
      this.setData({ scrollIntoView: 'historyBottom' });
    }, 300);
    
    setTimeout(() => {
      // 4. 清除锚点标记
        this.setData({ scrollIntoView: '' });
    }, 500);
    
    setTimeout(() => {
      // 5. 再次确保scrollTop
      console.log('再次确保scrollTop');
      this.setData({ scrollTop: 999998 });
    }, 700);
    
    // 6. 延时清理占位空间
    setTimeout(() => {
      if (this.data.forceScrollPadding) {
        console.log('清理占位空间');
        this.setData({ 
          forceScrollPadding: false,
          forceScrollPaddingHeight: 0
        });
      }
    }, 2000);
  },

  /**
   * 滚动到页面底部（最新记录）- 修复scrollTop不生效问题
   */
  scrollToBottom() {
    console.log('=== 开始滚动到底部 ===');
    console.log('历史记录数量:', this.data.historyList?.length || 0);

    // 检查是否需要强制创建滚动空间
    if (this.needForceScrollSpace) {
      console.log('💡 检测到高度不足，先创建滚动空间');
      this.createScrollSpace().then(() => {
        this.performScrollToBottom();
      });
    } else {
      this.performScrollToBottom();
    }
  },

  /**
   * 创建滚动空间（当内容高度不足时）
   */
  createScrollSpace() {
    return new Promise((resolve) => {
      console.log('=== 创建滚动空间 ===');
      console.log('计算得出的占位高度:', this.forceScrollPaddingHeight + 'px');
      
      // 使用计算出的动态高度创建占位空间
      this.setData({
        forceScrollPadding: true,
        forceScrollPaddingHeight: this.forceScrollPaddingHeight || 300
      });
      
      console.log('✅ 已添加', this.forceScrollPaddingHeight + 'px', '的底部占位空间');
      
      // 等待渲染完成
      setTimeout(() => {
        resolve();
      }, 500); // 增加等待时间确保渲染完成
    });
  },

  /**
   * 执行实际的滚动到底部操作
   */
  performScrollToBottom() {
    console.log('=== 执行滚动到底部 ===');
    
    // 关键修复：先重置scrollTop为0，确保后续设置能生效
    console.log('步骤1：重置scrollTop为0');
    this.setData({
      scrollTop: 0,
      scrollIntoView: ''
    });
    
    // 使用wx.nextTick确保上一步渲染完成
        wx.nextTick(() => {
      console.log('步骤2：设置scrollTop到大数值');
      this.setData({
        scrollTop: 99999999
      });
      
      // 延时后使用scroll-into-view作为双重保障
      setTimeout(() => {
        console.log('步骤3：使用scroll-into-view到底部锚点');
        this.setData({
          scrollIntoView: 'historyBottom'
        });
        
        // 再次使用scrollTop确保
    setTimeout(() => {
          console.log('步骤4：再次使用scrollTop确保');
          this.setData({
            scrollTop: 99999999,
            scrollIntoView: ''
          });

          // 步骤5: 延时清理临时占位（确保滚动完全完成）
          setTimeout(() => {
            if (this.data.forceScrollPadding) {
              console.log('步骤5：清理临时占位空间');
              this.setData({ 
                forceScrollPadding: false,
                forceScrollPaddingHeight: 0
              });
            }
          }, 2000); // 延长到2秒，确保滚动动画完成
        }, 300);
        
      }, 200);
    });
    
    console.log('=== 滚动执行完成 ===');
  },

  /**
   * 智能滚动到顶部方法（简化版，因为滚动到顶部非常简单）
   */
  scrollToTopWithCheck() {
    console.log('=== 智能滚动到顶部显示最新记录 ===');
    
    // 滚动到顶部不需要复杂的检查，直接执行即可
    setTimeout(() => {
      this.forceScrollToTop();
    }, 200); // 稍微延时确保DOM渲染完成
  },

  /**
   * 深度调试scroll-view高度信息
   */
  debugScrollHeight() {
    return new Promise((resolve) => {
      console.log('=== 深度调试scroll-view高度信息 ===');
      
      const query = wx.createSelectorQuery().in(this);
      query.select('.ai-generate-page').boundingClientRect();     // 整个页面
      query.select('.main-content-area').boundingClientRect();    // 主内容区域  
      query.select('.history-scroll-area').boundingClientRect();  // 滚动区域父容器
      query.select('.history-scroll-view').boundingClientRect();  // scroll-view本体
      query.select('.history-cards-container').boundingClientRect(); // 内容容器
      query.selectAll('.history-card').boundingClientRect();      // 所有历史卡片
      
      query.exec((res) => {
        console.log('=== 高度调试结果 ===');
        console.log('📱 整个页面:', res[0]);
        console.log('📦 主内容区域:', res[1]);
        console.log('📋 滚动区域父容器:', res[2]);
        console.log('🎯 scroll-view本体:', res[3]);
        console.log('📄 内容容器:', res[4]);
        console.log('📝 历史卡片数量:', res[5]?.length || 0);
        
        if (res[5] && res[5].length > 0) {
          console.log('📝 第一张卡片:', res[5][0]);
          console.log('📝 最后一张卡片:', res[5][res[5].length - 1]);
          
          // 计算总的内容高度
          const firstCard = res[5][0];
          const lastCard = res[5][res[5].length - 1];
          const totalContentHeight = (lastCard.bottom - firstCard.top);
          console.log('📏 内容总高度:', totalContentHeight + 'px');
        }
        
        const scrollView = res[3];
        const contentContainer = res[4];
        
        if (scrollView && contentContainer) {
          console.log('🔍 关键对比:');
          console.log('   - scroll-view高度:', scrollView.height + 'px');
          console.log('   - 内容容器高度:', contentContainer.height + 'px');
          console.log('   - 是否需要滚动:', contentContainer.height > scrollView.height ? '✅ 需要滚动' : '❌ 不需要滚动');
          
          if (contentContainer.height <= scrollView.height) {
            console.log('⚠️  检测到内容高度不足，内容默认顶部对齐！');
            console.log('⚠️  这就是为什么总是显示第一条记录的原因');
            console.log('💡 将强制创建足够的滚动空间，确保能滚动到底部');
            
            const needPadding = scrollView.height - contentContainer.height + 200; // 额外200px确保滚动
            console.log('💡 需要添加占位空间:', needPadding + 'px');
            
            this.needForceScrollSpace = true;
            this.forceScrollPaddingHeight = Math.max(needPadding, 300); // 至少300px
          } else {
            this.needForceScrollSpace = false;
            this.forceScrollPaddingHeight = 0;
          }
        }
        
        console.log('=== 高度调试完成 ===');
        resolve();
      });
    });
  },

  /**
   * 简化的滚动检查（避免使用有问题的scrollOffset API）
   */
  simpleScrollCheck() {
    return new Promise((resolve) => {
      console.log('=== 简化滚动检查 ===');
      
      const query = wx.createSelectorQuery().in(this);
      query.select('.history-scroll-view').boundingClientRect();
      query.select('.history-cards-container').boundingClientRect();
      
      query.exec((res) => {
        const scrollView = res[0];
        const contentContainer = res[1];
        
        console.log('简化检查结果:');
        console.log('- scroll-view:', scrollView);
        console.log('- 内容容器:', contentContainer);
        
        // 只检查元素是否存在和基本尺寸
        const canScroll = scrollView && scrollView.height > 0 && 
                         contentContainer && contentContainer.height > 0;
        
        console.log('简化检查结论:', canScroll ? '✅ 可以滚动' : '❌ 不能滚动');
        resolve(canScroll);
      });
    });
  },

  /**
   * 替代滚动方案（不依赖scrollTop）
   */
  useAlternativeScrollMethod() {
    console.log('=== 使用替代滚动方案 ===');
    
    // 如果检测到内容高度不足，先创建足够的滚动空间
    if (this.needForceScrollSpace) {
      console.log('替代方案：先创建滚动空间');
      this.setData({
        forceScrollPadding: true,
        forceScrollPaddingHeight: this.forceScrollPaddingHeight || 400
      });
    }
    
    setTimeout(() => {
      console.log('替代方案：使用scroll-into-view滚动到底部');
      
      // 方法1: 使用scroll-into-view到底部锚点
      this.setData({
        scrollIntoView: 'historyBottom'
      });
      
      setTimeout(() => {
        console.log('清除scroll-into-view标记');
      this.setData({ scrollIntoView: '' });
        
        // 方法2: 备用 - 滚动到最后一个历史记录
        if (this.data.historyList && this.data.historyList.length > 0) {
          const lastIndex = this.data.historyList.length - 1;
          const lastItemId = `history-${lastIndex}`;
          console.log('备用方案：滚动到最后一个记录', lastItemId);
          
          setTimeout(() => {
            this.setData({
              scrollIntoView: lastItemId
            });
            
            setTimeout(() => {
              this.setData({ scrollIntoView: '' });
            }, 500);
          }, 300);
        }
      }, 500);
      
      // 方法3: 最终备用 - 重复设置大数值scrollTop
      setTimeout(() => {
        console.log('终极备用：重复设置scrollTop大数值');
        for (let i = 0; i < 5; i++) {
          setTimeout(() => {
            this.setData({ scrollTop: 999999 - i }); // 每次数值略有不同
          }, i * 100);
        }
        
        // 清理占位空间
        setTimeout(() => {
          if (this.data.forceScrollPadding) {
            console.log('替代方案：清理占位空间');
            this.setData({ 
              forceScrollPadding: false,
              forceScrollPaddingHeight: 0 
            });
          }
        }, 1000);
      }, 1000);
      
    }, this.needForceScrollSpace ? 500 : 0);
    
    console.log('替代滚动方案执行完成');
  },

  /**
   * 诊断scroll-view状态
   */
  diagnoseScrollView() {
    return new Promise((resolve) => {
      console.log('=== 开始诊断scroll-view ===');
      
      const query = wx.createSelectorQuery().in(this);
      query.select('.history-scroll-area').boundingClientRect(); // 父容器
      query.select('.history-scroll-view').boundingClientRect(); // scroll-view
      query.select('.history-scroll-view').scrollOffset();       // 滚动信息
      query.select('.history-cards-container').boundingClientRect(); // 内容容器
      
      query.exec((res) => {
        const diagnostic = {
          parentContainer: res[0],
          scrollView: res[1], 
          scrollInfo: res[2],
          contentContainer: res[3],
          canScroll: false,
          issues: []
        };
        
        console.log('诊断数据:');
        console.log('- 父容器:', diagnostic.parentContainer);
        console.log('- scroll-view:', diagnostic.scrollView);
        console.log('- 滚动信息:', diagnostic.scrollInfo);
        console.log('- 内容容器:', diagnostic.contentContainer);
        
        // 检查各项条件
        if (!diagnostic.scrollView) {
          diagnostic.issues.push('scroll-view不存在');
        } else {
          if (diagnostic.scrollView.height <= 0) {
            diagnostic.issues.push(`scroll-view高度异常: ${diagnostic.scrollView.height}`);
          }
        }
        
        if (!diagnostic.scrollInfo) {
          diagnostic.issues.push('无法获取滚动信息');
        } else {
          if (!diagnostic.scrollInfo.scrollHeight || diagnostic.scrollInfo.scrollHeight <= 0) {
            diagnostic.issues.push(`scrollHeight异常: ${diagnostic.scrollInfo.scrollHeight}`);
          }
          if (!diagnostic.scrollInfo.clientHeight || diagnostic.scrollInfo.clientHeight <= 0) {
            diagnostic.issues.push(`clientHeight异常: ${diagnostic.scrollInfo.clientHeight}`);
          }
        }
        
        if (!diagnostic.contentContainer) {
          diagnostic.issues.push('内容容器不存在');
        } else {
          if (diagnostic.contentContainer.height <= 0) {
            diagnostic.issues.push(`内容容器高度异常: ${diagnostic.contentContainer.height}`);
          }
        }
        
        // 综合判断
        diagnostic.canScroll = diagnostic.issues.length === 0 && 
          diagnostic.scrollView && diagnostic.scrollView.height > 0 &&
          diagnostic.scrollInfo && diagnostic.scrollInfo.scrollHeight > 0 &&
          diagnostic.scrollInfo.clientHeight > 0;
          
        resolve(diagnostic);
      });
    });
  },

  /**
   * 修复scroll-view问题
   */
  fixScrollViewIssues(diagnostic) {
    return new Promise((resolve) => {
      console.log('=== 尝试修复scroll-view问题 ===');
      
      // 修复方法1: 强制重新设置高度
      if (diagnostic.issues.some(issue => issue.includes('高度异常'))) {
        console.log('修复方法: 强制重新计算高度');
        
        // 临时修改样式，触发重新计算
        this.setData({ tempScrollViewRefresh: Date.now() });
        
        setTimeout(() => {
          resolve();
        }, 300);
        return;
      }
      
      // 修复方法2: 延时等待渲染完成
      console.log('修复方法: 延时等待渲染完成');
      setTimeout(() => {
        resolve();
      }, 800);
    });
  },

  /**
   * 验证滚动位置是否成功（简化版，避免使用有问题的scrollOffset）
   */
  verifyScrollPosition() {
    console.log('=== 验证滚动位置（简化版）===');
    
    // 不再依赖有问题的scrollOffset API
    // 直接使用scroll-into-view作为验证后的保险
    setTimeout(() => {
      console.log('验证步骤：使用scroll-into-view确保滚动到底部');
      this.setData({
        scrollIntoView: 'historyBottom'
      });
      
      setTimeout(() => {
        console.log('清除scroll-into-view标记');
        this.setData({ scrollIntoView: '' });
        console.log('✅ 滚动验证完成');
      }, 300);
    }, 200);
  },

  /**
   * 强制滚动到底部（终极方案）
   */
  forceScrollToBottom() {
    console.log('=== 强制滚动到底部（终极方案）===');
    
    let retryCount = 0;
    const maxRetries = 3;
    
    const attemptScroll = () => {
      console.log(`强制滚动尝试 ${retryCount + 1}/${maxRetries}`);
      
      // 方法1：重置然后设置大数值
      this.setData({ scrollTop: 0, scrollIntoView: '' });
      
        wx.nextTick(() => {
        this.setData({ scrollTop: 999999 });
        console.log('设置scrollTop为999999');
        
        // 方法2：同时使用scroll-into-view
        setTimeout(() => {
          this.setData({ 
            scrollIntoView: 'historyBottom' 
          });
          console.log('设置scrollIntoView为historyBottom');
          
          // 方法3：再次设置scrollTop
          setTimeout(() => {
            this.setData({ 
              scrollTop: 888888,
              scrollIntoView: ''
            });
            console.log('再次设置scrollTop为888888');
            
            // 验证这次是否成功
            setTimeout(() => {
              this.finalVerifyScroll(retryCount, maxRetries, attemptScroll);
            }, 500);
            
          }, 300);
        }, 200);
      });
    };
    
    attemptScroll();
  },

  /**
   * 最终验证滚动（带重试机制）
   */
  finalVerifyScroll(retryCount, maxRetries, retryCallback) {
    console.log('=== 最终验证滚动 ===');
    
    const query = wx.createSelectorQuery().in(this);
    query.select('.history-scroll-view').scrollOffset();
    
    query.exec((res) => {
      if (res && res[0]) {
        const scrollInfo = res[0];
        const scrollTop = scrollInfo.scrollTop || 0;
        
        console.log('最终验证 - scrollTop:', scrollTop);
        console.log('最终验证 - scrollInfo:', scrollInfo);
        
        if (scrollTop > 0) {
          console.log('🎉 强制滚动成功！scrollTop:', scrollTop);
        } else {
          console.log('❌ 强制滚动失败，scrollTop仍为0');
          
          if (retryCount < maxRetries - 1) {
            console.log('准备重试...');
            retryCount++;
            setTimeout(retryCallback, 800);
          } else {
            console.log('❌ 已达到最大重试次数，滚动彻底失败');
            // 最后的绝招：直接操作DOM（如果可以的话）
            this.ultimateScrollSolution();
          }
        }
      } else {
        console.log('无法验证滚动结果');
      }
    });
  },

  /**
   * 最终解决方案（终极绝招）
   */
  ultimateScrollSolution() {
    console.log('=== 使用终极解决方案 ===');
    
    // 尝试多种不同的数值
    const scrollValues = [999999, 888888, 777777, 100000, 50000];
    
    scrollValues.forEach((value, index) => {
      setTimeout(() => {
        console.log(`终极方案 ${index + 1}: 设置scrollTop为${value}`);
        this.setData({ scrollTop: value });
        
        if (index === 0) {
          // 第一次也设置scroll-into-view
          setTimeout(() => {
            this.setData({ scrollIntoView: 'historyBottom' });
          }, 100);
        }
      }, index * 200);
    });
    
    // 最后清理scroll-into-view
    setTimeout(() => {
      this.setData({ scrollIntoView: '' });
    }, scrollValues.length * 200 + 500);
  },

  /**
   * 精确计算滚动到底部（备用方法）
   */
  scrollToBottomPrecise() {
    const query = wx.createSelectorQuery().in(this);
    query.select('.history-scroll-view').scrollOffset();
    
    query.exec((res) => {
      if (res && res[0]) {
        const scrollInfo = res[0];
        const maxScrollTop = Math.max(0, scrollInfo.scrollHeight - scrollInfo.scrollTop);
        
        console.log('精确计算 - 最大滚动位置:', maxScrollTop);
        console.log('精确计算 - 滚动信息:', scrollInfo);
        
        if (maxScrollTop > 0) {
          this.setData({
            scrollTop: maxScrollTop
          });
          console.log('精确计算 - 设置scrollTop为:', maxScrollTop);
        }
      }
    });
  },

  /**
   * 滚动到指定历史索引
   */
  scrollToHistoryIndex(index) {
    console.log('scrollToHistoryIndex ->', index);
    if (index < 0 || !this.data.historyList || index >= this.data.historyList.length) {
      console.log('无效的历史记录索引:', index);
      return;
    }
    
    // 使用scroll-into-view滚动到指定记录
    const targetId = `history-${index}`;
    console.log('滚动到历史记录:', targetId);
    
    this.setData({
      scrollIntoView: '',
      scrollTop: 0
    });
    
    setTimeout(() => {
      this.setData({
        scrollIntoView: targetId
      });
    }, 100);
    
    // 清理
    setTimeout(() => {
      this.setData({
        scrollIntoView: ''
      });
    }, 1000);
  },

  /**
   * 获取AI生图所需积分
   */
  async getAiImageCreditsCost() {
    try {
      const response = await api.getCreditsConsumptionRules();
      if (response.success && response.data) {
        const aiImageRule = response.data.find(rule => rule.type === 'ai_image');
        return aiImageRule ? aiImageRule.cost : 10; // 默认10积分
      }
      return 10; // 默认10积分
    } catch (error) {
      console.error('获取积分消耗规则失败:', error);
      return 10; // 默认10积分
    }
  },

  /**
   * 检查并消耗积分
   */
  async checkAndConsumeCredits(creditsRequired, prompt) {
    try {
      // 检查积分是否足够
      const checkResponse = await api.checkCreditsEnough(creditsRequired);
      if (!checkResponse.success || !checkResponse.data) {
        // 积分不足，引导用户充值
        wx.showModal({
          title: '积分不足',
          content: `AI生图需要消耗${creditsRequired}积分，您的积分不足。是否前往充值？`,
          confirmText: '去充值',
          cancelText: '取消',
          success: (res) => {
            if (res.confirm) {
              wx.navigateTo({
                url: '/pages/profile/credits/credits'
              });
            }
          }
        });
        return false;
      }

      console.log('积分检查通过，开始生成图片');
      return true;
    } catch (error) {
      console.error('积分检查失败:', error);
      wx.showToast({
        title: '积分检查失败，请稍后重试',
        icon: 'none'
      });
      return false;
    }
  }
});
